package com.rockontrol.ele.service.impl;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.log4j.Logger;

import com.rksp.util.DatabaseUtil;
import com.rksp.util.DateUtil;
import com.rksp.util.StringUtil;
import com.rockontrol.ele.pojo.Ba物资分类;
import com.rockontrol.ele.pojo.Ma回收单;
import com.rockontrol.ele.pojo.Ma安装位置;
import com.rockontrol.ele.pojo.Ma帐套;
import com.rockontrol.ele.pojo.Ma报废单;
import com.rockontrol.ele.pojo.Ma物资流程审批;
import com.rockontrol.ele.pojo.Ma移交单;
import com.rockontrol.ele.pojo.Ma维修计划;
import com.rockontrol.ele.pojo.Ma维修计划明细;
import com.rockontrol.ele.pojo.Ma设备;
import com.rockontrol.ele.pojo.Ma设备台帐;
import com.rockontrol.ele.pojo.Ma设备巡检信息;
import com.rockontrol.ele.pojo.Ma设备报废明细;
import com.rockontrol.ele.service.MaEquipmentSvc;
import com.rockontrol.ele.service.model.dbtransaction.MaEquipmentTrans;
import com.rockontrol.ele.service.skeleton.MaEquipmentSvcSkeleton;
import com.rockontrol.ele.vo.LocCdt;
import com.rockontrol.ele.vo.MaCdt;
import com.rockontrol.ele.vo.MaEqnagementVo;
import com.rockontrol.ele.vo.MaEqpollingCdt;
import com.rockontrol.ele.vo.MaLedger;
import com.rockontrol.ele.vo.MaLedgerCdt;
import com.rockontrol.ele.vo.MaMultipleInfo;
import com.rockontrol.ele.vo.MaOverhaulCnt;
import com.rockontrol.ele.vo.MaOverhaulCntCdt;
import com.rockontrol.ele.vo.MaOverhaulPlanCdt;
import com.rockontrol.ele.vo.MaRecoverCdt;
import com.rockontrol.ele.vo.MaTransferCdt;
import com.rockontrol.ele.vo.MaValue;
import com.rockontrol.ele.vo.MascrapCdt;

public class MaEquipmentSvcImpl extends MaEquipmentSvcSkeleton implements MaEquipmentSvc{
    private static Logger log = Logger.getLogger(MaEquipmentSvcImpl.class);

    private MaEquipmentTrans maEquipmentTrans;

    /**
     *分页接口
     *@author 杨晶
     *@version 1.0, Sat Mar 31 00:00:00 CST 2012
     *@param 页数和分页参数
     *@return
     */
    public String pageNumEquipment(Integer num, String roll){
        try{
            return super.pageNum(roll, num);
        }catch(Exception e){
            log.error(e.getMessage(),e);
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 创建设备基本信息
     * @param Eq_
     * @return String 设备ID, NULL 失败
     */
    public String createEquipment(Ma设备 Eq_){
    	try{
    		service.addObj(Eq_);
    		return Eq_.getOid();
    	}catch(Exception e){
    		log.error(e.getMessage(),e);
    		e.printStackTrace();
    		return null;
    	}

    }

    /**
     * 根据设备ID获取设备基本信息
     * @param id_
     * @return Ma设备 设备对象, NULL 失败
     */
    public Ma设备 getEquipment(String id_){
        try{
            return (Ma设备)service.findObj(Ma设备.class, id_);
        }catch(Exception e){
			log.error(e.getMessage(),e);
            return null;
        }
        
    }

    /**
     * 根据设备编号获取设备基本信息 
     * 2013-03-21 杨晶 code传入rfid的epc编码也能查询设备
     * @param code
     * @return Eq设备 设备对象, NULL 失败
     */
    public Ma设备 getEquipmentByCode(String code){
        try{
            String sqlString="from Ma设备 eq where eq.设备编码 like '%"+code+"%' or eq.rfid='"+code+"'";
            List<Ma设备> list= service.findObjsHQL(sqlString);
            
            return list==null||list.isEmpty()?null:list.get(0);
        }catch(Exception e){
			log.error(e.getMessage(),e);
            return null;
        }
    }

    /**
     * 根据设备分类获取最大的设备编码
     * @param typeid
     * @return String 设备编码, NULL 失败
     */
 
    public String getEquipmentCodeByType(String typeid, String modelid) {
		try {
			String hql="from Ba物资分类 where oid='"+typeid+"'";
			Ba物资分类 fl=(Ba物资分类)service.findObjsHQL(hql).get(0);
			String sb=fl.get所属设备();
			StringBuffer sql=new StringBuffer("select max(substr(a.设备编码,instr(a.设备编码,'-',-1),10)) from MA_设备 a where 1=1");
			if(!StringUtil.isEmpty(typeid))
				sql.append(" and a.设备分类ID ='").append(typeid).append("'");
			if(!StringUtil.isEmpty(modelid))
				sql.append(" and a.设备型号ID ='").append(modelid).append("'");
			List list=service.findSQL(sql.toString());
			if(list.size()>0)
				return (String) list.get(0);
		} catch (Exception e) {
			log.error(e.getMessage(),e);
		}
		return null;
	}
    private String sqlgetEquipments(MaCdt op_){
        String dataBaseType = DatabaseUtil.getDataBaseType(dataSource);
        StringBuffer sql=new StringBuffer();
        if("SQLSERVER".equals(dataBaseType)){
                //数据库为sqlserver时执行的操作
            sql.append("select CONVERT(VARCHAR(32),eq.OID) as oid,eq.设备编码 as 设备编码,eq.设备名称 as 设备名称,CONVERT(VARCHAR(32),eq.设备分类ID) as 设备分类id,eq.分类编码 as 分类编码,eq.分类名称 as 分类名称,CONVERT(VARCHAR(32),eq.设备型号ID) as 设备型号id,")
            .append("eq.设备型号 as 设备型号,eq.设备类型 as 设备类型,eq.设备状态 as 设备状态,eq.出厂编号 as 出厂编号,eq.购买单价 as 购买单价,CONVERT(VARCHAR(32),eq.生产商ID) as 生产商id,eq.生产商名称 as 生产商名称,CONVERT(VARCHAR(32),eq.供货商ID) as 供货商id,eq.供货商名称,CONVERT(VARCHAR(32),eq.维修单位ID) as 维修单位id,")
            .append("eq.维修商名称 as 维修商名称,CONVERT(VARCHAR(32),t.使用单位ID) as 使用单位id,eq.维修商联系人 as 维修商联系人,eq.维修商联系电话 as 维修商联系电话,eq.出厂日期 as 出厂日期,eq.到货日期 as 到货日期,eq.验收时间 as 验收时间,CONVERT(VARCHAR(32),eq.验收人ID) as 验收人id,eq.验收人姓名 as 验收人姓名,eq.录入时间 as 录入时间,CONVERT(VARCHAR(32),eq.录入人ID) as 录入人id,eq.录入人姓名 as 录入人姓名,CONVERT(VARCHAR(32),eq.安装地点ID) as 安装地点id,eq.安装地点 as 安装地点,eq.设备管理类型 as 设备管理类型,")
            .append("eq.备注 as 备注  from Ma_设备 as eq,Ma_设备台帐 as t where eq.oid=t.设备id ");
        }else if("ORACLE".equals(dataBaseType)){
                //数据库为oracle时执行的操作
            sql.append("select to_char(eq.OID) as \"oid\",eq.设备编码 as 设备编码,eq.设备名称 as 设备名称,to_char(eq.设备分类ID) as \"设备分类id\",eq.分类编码 as 分类编码,eq.分类名称 as 分类名称,to_char(eq.设备型号ID) as \"设备型号id\",")
            .append("eq.设备型号 as 设备型号,eq.设备类型 as 设备类型,eq.设备状态 as 设备状态,eq.出厂编号 as 出厂编号,eq.购买单价 as 购买单价,to_char(eq.生产商ID) as \"生产商id\",eq.生产商名称 as 生产商名称,to_char(eq.供货商ID) as \"供货商id\",eq.供货商名称,to_char(eq.维修单位ID) as \"维修单位id\",")
            .append("eq.维修商名称 as 维修商名称," +
            		//"to_char(t.使用单位ID) as \"使用单位id\"," +
            		"eq.维修商联系人 as 维修商联系人,eq.维修商联系电话 as 维修商联系电话,eq.出厂日期 as 出厂日期,eq.到货日期 as 到货日期,eq.验收时间 as 验收时间,to_char(eq.验收人ID) as \"验收人id\",eq.验收人姓名 as 验收人姓名,eq.录入时间 as 录入时间,to_char(eq.录入人ID) as \"录入人id\",eq.录入人姓名 as 录入人姓名,to_char(eq.安装地点ID) as \"安装地点id\",eq.安装地点 as 安装地点,eq.设备管理类型 as 设备管理类型,")
            .append("eq.备注 as 备注  from Ma_设备 eq,Ma_设备台帐  t where eq.oid=t.设备id ");
        }
        if(op_!=null){
        	if (!StringUtil.isEmpty(op_.get类型分类())) {
        		sql.append(" and eq.设备类型='"+op_.get类型分类()+"'");
			}
            if(!StringUtil.isEmpty(op_.get使用单位ID())){
                sql.append(" and t.使用单位id='"+op_.get使用单位ID()+"'");
            }
            if(!StringUtil.isEmpty(op_.get分类ID())){
                sql.append(" and eq.设备分类id='"+op_.get分类ID()+"'");
            }
            if(!StringUtil.isEmpty(op_.get设备使用单位())){
                sql.append(" and t.使用单位 like'%"+op_.get设备使用单位()+"%'");
            }
            if(StringUtil.isEmpty(op_.getQueryState())){
	            if(!StringUtil.isEmpty(op_.get设备使用状态())){
	                sql.append(" and eq.设备状态='"+op_.get设备使用状态()+"'");
	            }
            }else if("1".equals(op_.getQueryState())){
            	if (!StringUtil.isEmpty(op_.get设备使用状态())) {
            		sql.append(" and eq.设备状态<> '" + op_.get设备使用状态() + "' ");
				}
            }else if("2".equals(op_.getQueryState())){
            	if (!StringUtil.isEmpty(op_.get设备使用状态())) {
					String[] ztList=op_.get设备使用状态().split(",");
					String hqlIn = "";
					for(int i=0;i<ztList.length;i++){
						if(i == 0){
							hqlIn += "'"+ztList[i]+"'";
						}else{
							hqlIn += ", '" + ztList[i]+"'";
						}
					}
					sql.append(" and eq.设备状态  in (" + hqlIn+ ") ");
				}
            }
            if(!StringUtil.isEmpty(op_.get设备名称())){
                sql.append(" and eq.设备名称='"+op_.get设备名称()+"'");
            }
            if(!StringUtil.isEmpty(op_.get设备型号ID())){
                sql.append(" and eq.设备型号id='"+op_.get设备型号ID()+"'");
            }
            if(!StringUtil.isEmpty(op_.get设备管理状态())){
                sql.append(" and t.状态 ='"+op_.get设备管理状态()+"'");
            }
            if(!StringUtil.isEmpty(op_.get设备管理类型())){
                sql.append(" and eq.设备管理类型='"+op_.get设备管理类型()+"'");
            }
            if(!StringUtil.isEmpty(op_.get设备编号())){
                sql.append(" and eq.设备编码 like '%"+op_.get设备编号()+"%'");
            }
            if(!StringUtil.isEmpty(op_.get起始出厂日期())){
                if("SQLSERVER".equals(dataBaseType)){
                    //数据库为sqlserver时执行的操作
                    sql.append(" and eq.出厂日期 >= '"+op_.get起始出厂日期()+"'");
                }else if("ORACLE".equals(dataBaseType)){
                        //数据库为oracle时执行的操作
                    sql.append(" and eq.出厂日期>= to_date('").append(op_.get起始出厂日期()).append(" 23:59:59','yyyy-mm-dd hh24:mi:ss')");
                }
            }
            if(!StringUtil.isEmpty(op_.get结束出厂日期())){
                if("SQLSERVER".equals(dataBaseType)){
                    //数据库为sqlserver时执行的操作
                    sql.append(" and eq.出厂日期 <= '"+op_.get结束出厂日期()+"'");
                }else if("ORACLE".equals(dataBaseType)){
                        //数据库为oracle时执行的操作
                    sql.append(" and eq.出厂日期 <=to_date('").append(op_.get结束出厂日期()).append(" 23:59:59','yyyy-mm-dd hh24:mi:ss')");
                }
            }
            if(!StringUtil.isEmpty(op_.get起始到货日期())){
                if("SQLSERVER".equals(dataBaseType)){
                    //数据库为sqlserver时执行的操作
                    sql.append(" and eq.到货日期 >= '"+op_.get起始到货日期()+"'");
                }else if("ORACLE".equals(dataBaseType)){
                        //数据库为oracle时执行的操作
                    sql.append("eq.到货日期>= to_date('").append(op_.get起始到货日期()).append(" 23:59:59','yyyy-mm-dd hh24:mi:ss')");
                }

            }
            if(!StringUtil.isEmpty(op_.get结束到货日期())){
                if("SQLSERVER".equals(dataBaseType)){
                    //数据库为sqlserver时执行的操作
                    sql.append(" and eq.到货日期 <= '"+op_.get结束到货日期()+"'");
                }else if("ORACLE".equals(dataBaseType)){
                        //数据库为oracle时执行的操作
                    sql.append(" and eq.到货日期<= to_date('").append(op_.get结束到货日期()).append(" 23:59:59','yyyy-mm-dd hh24:mi:ss')");
                }
            }
            
            sql.append(" order by eq.设备编码  desc");
        }
        return sql.toString();
    }
    
    public List<Ma设备> getEquipmentList(MaCdt op_){
        StringBuffer hql=new StringBuffer(" from  Ma设备 eq where 1=1");
        if(op_ != null){
            if(!StringUtil.isEmpty(op_.get设备编号())){
                hql.append(" and eq.设备编码 = '"+op_.get设备编号()+"'");
            }
        }
        List<Ma设备> list = service.findObjsHQL(hql.toString());
        if(list != null && list.size() != 0){
            return list;
        }
        return null;
    }
    
    /**
     * 根据查询条件获取设备基本信息集
     * @param op_
     * @return List<Eq设备> 设备信息集, NULL 失败
     */
    public List<Ma设备> getEquipments(MaCdt op_){
        try{
            return service.findSQLAlias(sqlgetEquipments(op_),Ma设备.class);
        }catch(Exception e){
			log.error(e.getMessage(),e);
           return null;
        }
        
    }

    public String pageInitGetEquipments(MaCdt op_, String roll_){
        try{
            return pageFind(roll_, sqlgetEquipments(op_),new HashMap(),4,Ma设备.class);
        }catch(Exception e){
			log.error(e.getMessage(),e);
            return null;
        }
    }

    /**
     * 修改设备基本信息
     * @param Eq_
     * @return True 成功, False 失败
     */
    public Boolean updateEquipment(Ma设备 Eq_){
        try{
            service.modifyObj(Eq_);
            return true;
        }catch(Exception e){
			log.error(e.getMessage(),e);
           return false;
        }
    }

    /**
     * 根据设备ID删除设备基本信息
     * @param id_
     * @return True 成功, False 失败
     */
    public Boolean deleteEquipment(String id_){
        try{
            service.removeObj(Ma设备.class, id_);
            return true;
        }catch(Exception e){
			log.error(e.getMessage(),e);
            return false;
        }
        
       
    }

	public String createEquipmentManagment(Ma设备台帐 eq) {
		try {
		    String sqlString="from Ma帐套  a where a.单位id='"+eq.get使用单位id()+"'";
		    Ma帐套 zt=(Ma帐套)service.findObjsHQL(sqlString).get(0);
		    if(zt!=null){
		        eq.set帐套id(zt.getOid());
		    }else{
		        return null;
		    }
			eq.set状态("在管");
			service.addObj(eq);
			return eq.getOid();
		} catch (Exception e) {
			log.error(e.getMessage(),e);
            return null;
		}
	}

	public Boolean deleteEquipmentManagement(String id) {
		try {
			service.removeObj(Ma设备台帐.class,id);
			return true;
		} catch (Exception e) {
			log.error(e.getMessage(),e);
            return false;
		}
	}

	public Ma设备台帐 getEquipmentManagement(String id) {
		try {
			return (Ma设备台帐) service.findObj(Ma设备台帐.class,id);
		} catch (Exception e) {
			log.error(e.getMessage(),e);
            return null;
		}
	}

	public Ma设备台帐 getEquipmentManagementByEqId(String id) {
		try {
			if (!StringUtil.isEmpty(id)) {
				String hql = " from Ma设备台帐  t where t.状态='在管' and t.设备id ='" + id.trim()+ "' ";
				List<Ma设备台帐> vl = (List<Ma设备台帐>) service.findObjsHQL(hql);
				return vl.size() > 0 ? vl.get(0) : null;
			}
			return null;
		} catch (Exception e) {
			log.info(e.getMessage(),e);
			return null;
		}
	}

	public List<Ma设备台帐> getEquipmentManagements(String eqId) {
		try {
			return service.findObjsHQL(getEquipmentManagementsSql(eqId));
		} catch (Exception e) {
			log.info(e.getMessage(),e);
			return null;
		}
	}

	public String pageInitGetEquipmentManagements(String eqId, String roll) {
		try {
			return pageFind(roll, getEquipmentManagementsSql(eqId));
		} catch (Exception e) {
			log.info(e.getMessage(),e);
			return null;
		}
	}

	private String getEquipmentManagementsSql(String eqId){
		StringBuffer sql=new StringBuffer("from Ma设备台帐 a where 1=1 ");
		if(!StringUtil.isEmpty(eqId))
			sql.append(" and a.设备id='").append(eqId).append("'");
		return sql.toString();
	}
	
	public Boolean updateEquipmentManagement(Ma设备台帐 eq) {
		try {
			service.modifyObj(eq);
			return true;
		} catch (Exception e) {
			log.error(e.getMessage(),e);
            e.printStackTrace();
            return false;
		}
	}

    /**
     * 根据设备ID获取设备综合信息
     * @param id_
     * @return EqMultipleInfo 设备综合信息, NULL 失败
     */
    public MaMultipleInfo getEqMultipleInfo(String id_){
        MaMultipleInfo mult=new MaMultipleInfo();
        List<Integer> numlist = new ArrayList<Integer>();
        List<Ma设备台帐> eqlist ;
        Ma设备 eq=getEquipment(id_);
        mult.setMa_(eq);
        if (eq != null && eq.get到货日期() != null)
            mult.setUseYear(String.valueOf(DateUtil.calTwoTimeSpace(eq.get到货日期(), new Date(), Calendar.YEAR)));
        
        String yjsql = " select count(*) from MA_设备移交明细   where 设备ID ='" + id_ + "' ";// 设备移交次数
        String dxsql = " select count(*) from MA_维修计划明细   where 维修设备ID ='" + id_+ "' and  维修类型 ='大修' and 维修状态<>'计划'";// 设备大修次数
        String hssql = " select COUNT(*) from MA_设备回收明细   where 设备ID='" + id_ + "'";//设备回收次数
        
        numlist = (List<Integer>)service.findSQL(dxsql);
        mult.setOverhaulCnt(String.valueOf(numlist.size() > 0 ? numlist.get(0): 0));

        numlist = (List<Integer>)service.findSQL(yjsql);
        mult.setTurnCnt(String.valueOf(numlist.size() > 0 ? numlist.get(0) : 0));
        
        numlist = (List<Integer>)service.findSQL(hssql);
        mult.setRecoverCnt(String.valueOf(numlist.size() > 0 ? numlist.get(0) : 0));

        String hql = " from  Ma设备台帐  eq  where  eq.设备id='" + id_ + "' "; // 根据设备id,查设备台帐明细
        eqlist = (List<Ma设备台帐>) service.findObjsHQL(hql);
        mult.setEm_(eqlist.size() > 0 ? eqlist : null);
        mult.setCoalProducedCnt("");
        return mult;
    }

    /**
     * 获取设备以及设备关联台帐明细的信息集
     * @param op
     * @return List< MaEqnagementVo >, Null 失败
     */
    public List<MaEqnagementVo> getEqdetails(MaCdt op_){
    	try {
			return service.findSQLAlias(getEqdetailsSql(op_), MaEqnagementVo.class);
		} catch (Exception e) {
			log.error(e.getMessage(),e);
			return null;
		}    	
    }

    public String pageInitGetEqdetails(MaCdt cdt,String roll){
    	try {
			return pageFind(roll, getEqdetailsSql(cdt), new HashMap(),4,MaEqnagementVo.class);
		} catch (Exception e) {
			log.error(e.getMessage(),e);
			return null;
		}
    }
    
    public String getEqdetailsSql(MaCdt op_){
        String dataBaseType = DatabaseUtil.getDataBaseType(dataSource);
        StringBuffer sql = new StringBuffer();
        if("SQLSERVER".equals(dataBaseType)){
                //数据库为sqlserver时执行的操作
            sql.append("select CONVERT(VARCHAR(32),tsb.oid) as oid, tsb.设备编码 as 设备编码,tsb.分类名称 as 设备名称,tsb.分类名称 as 分类名称,tsb.设备型号 as 设备型号,convert(varchar(32), tsb.设备分类ID) as 分类id,convert(varchar(32), tsb.设备型号ID) as 型号id,tsb.出厂日期 as 出厂日期, tsb.到货日期 as 到货日期 ,tmx.安装位置 as 安装位置,")
            .append("tsb.备注 as 备注,tsb.所属系统 as 所属系统,tsb.设备状态 as 状态,tmx.安装时间 as 安装时间,tsb.购买单价 as 购买单价,convert(varchar(32), tmx.负责人id) as 使用人id,tmx.负责人姓名 as 使用人,tmx.调入时间 as 调入时间,tmx.使用单位 as 使用单位,tsb.生产商名称 as 生产厂商, tsb.设备管理类型 as 设备管理类型 ")
            .append("from MA_设备 tsb left join MA_设备台帐 tmx on tsb.oid = tmx.设备ID and tmx.状态='在管' where 1=1 ");
        }else if("ORACLE".equals(dataBaseType)){
                //数据库为oracle时执行的操作
            sql.append("select to_char(tsb.oid) as \"oid\",tsb.工艺编号 as 工艺编号,tsb.设备编码 as 设备编码,tsb.分类名称 as 设备名称,tsb.分类名称 as 分类名称,tsb.设备型号 as 设备型号,to_char(tsb.设备分类ID) as \"分类id\",to_char(tsb.设备型号ID) as \"型号id\",tsb.出厂日期 as 出厂日期, tsb.到货日期 as 到货日期 ,tmx.安装位置 as 安装位置,")
            .append("tsb.备注 as 备注,tsb.所属系统 as 所属系统,tsb.设备状态 as 状态,tmx.安装时间 as 安装时间,tsb.购买单价 as 购买单价,to_char(tmx.负责人id) as \"使用人id\",tmx.负责人姓名 as 使用人,tmx.调入时间 as 调入时间,tmx.使用单位 as 使用单位,tsb.生产商名称 as 生产厂商, tsb.设备管理类型 as 设备管理类型 ")
            .append("from MA_设备 tsb left join MA_设备台帐 tmx on tsb.oid = tmx.设备ID  where 1=1 ");
        }   

        
    	if(!StringUtil.isEmpty(op_.get所属系统())){
    	    sql.append(" and tsb.所属系统 like'%"+op_.get所属系统()+"%'");
    	}
    	    if (op_ != null) {
    		if (!StringUtil.isEmpty(op_.get类型分类())) {
        		sql.append(" and tsb.设备型号='"+op_.get类型分类()+"'");
			}
            if(!StringUtil.isEmpty(op_.get使用单位ID())){
                sql.append(" and tmx.使用单位id='"+op_.get使用单位ID()+"'");
            }
//            if(!StringUtil.isEmpty(op_.get分类ID())){
//                sql.append(" and tsb.设备分类id='"+op_.get分类ID()+"'");
//            }
            if(!StringUtil.isEmpty(op_.get设备使用单位())){
                sql.append(" and tmx.使用单位 like'%"+op_.get设备使用单位()+"%'");
            }
            if(!StringUtil.isEmpty(op_.get生产厂商())){
                sql.append(" and tsb.生产厂商 like'%"+op_.get生产厂商()+"%'");
            }
            if(StringUtil.isEmpty(op_.getQueryState())){
	            if(!StringUtil.isEmpty(op_.get设备使用状态())){
	                sql.append(" and tsb.设备状态='"+op_.get设备使用状态()+"'");
	            }
            }else if("1".equals(op_.getQueryState())){
            	if (!StringUtil.isEmpty(op_.get设备使用状态())) {
            		sql.append(" and tsb.设备状态<> '" + op_.get设备使用状态() + "' ");
				}
            }else if("2".equals(op_.getQueryState())){
            	if (!StringUtil.isEmpty(op_.get设备使用状态())) {
					String[] ztList=op_.get设备使用状态().split(",");
					String hqlIn = "";
					for(int i=0;i<ztList.length;i++){
						if(i == 0){
							hqlIn += "'"+ztList[i]+"'";
						}else{
							hqlIn += ", '" + ztList[i]+"'";
						}
					}
					sql.append(" and tsb.设备状态  in (" + hqlIn+ ") ");
				}
            }
            if(!StringUtil.isEmpty(op_.get设备名称())){
                sql.append(" and tsb.设备名称='"+op_.get设备名称()+"'");
            }
            if(!StringUtil.isEmpty(op_.get设备型号ID())){
                sql.append(" and tsb.设备型号id='"+op_.get设备型号ID()+"'");
            }
            if(!StringUtil.isEmpty(op_.get设备管理状态())){
                sql.append(" and tmx.状态 ='"+op_.get设备管理状态()+"'");
            }
            if(!StringUtil.isEmpty(op_.get设备管理类型())){
                sql.append(" and tsb.设备管理类型='"+op_.get设备管理类型()+"'");
            }
            if(!StringUtil.isEmpty(op_.get设备编号())){
                sql.append(" and tsb.设备编码 like '%"+op_.get设备编号()+"%'");
            }
            if(!StringUtil.isEmpty(op_.get起始出厂日期())){
                if("SQLSERVER".equals(dataBaseType)){
                    //数据库为sqlserver时执行的操作
                    sql.append(" and tsb.出厂日期 >= '"+op_.get起始出厂日期()+"'");
                }else if("ORACLE".equals(dataBaseType)){
                        //数据库为oracle时执行的操作
                    sql.append(" and tsb.出厂日期 >= to_date('").append(op_.get起始出厂日期()).append(" 23:59:59','yyyy-mm-dd hh24:mi:ss')");
                }
            }
            if(!StringUtil.isEmpty(op_.get结束出厂日期())){
                if("SQLSERVER".equals(dataBaseType)){
                    //数据库为sqlserver时执行的操作
                    sql.append(" and tsb.出厂日期 <= '"+op_.get结束出厂日期()+"'");
                }else if("ORACLE".equals(dataBaseType)){
                        //数据库为oracle时执行的操作
                    sql.append(" and tsb.出厂日期<=  to_date('").append(op_.get结束出厂日期()).append(" 23:59:59','yyyy-mm-dd hh24:mi:ss')");
                }
            }
            if(!StringUtil.isEmpty(op_.get起始到货日期())){
                if("SQLSERVER".equals(dataBaseType)){
                    //数据库为sqlserver时执行的操作
                    sql.append(" and tsb.到货日期 >= '"+op_.get起始到货日期()+"'");
                }else if("ORACLE".equals(dataBaseType)){
                        //数据库为oracle时执行的操作
                    sql.append(" and tsb.到货日期>= to_date('").append(op_.get起始到货日期()).append(" 23:59:59','yyyy-mm-dd hh24:mi:ss')");
                }
            }
            if(!StringUtil.isEmpty(op_.get结束到货日期())){
                if("SQLSERVER".equals(dataBaseType)){
                    //数据库为sqlserver时执行的操作
                    sql.append(" and tsb.到货日期 <= '"+op_.get结束到货日期()+"'");
                }else if("ORACLE".equals(dataBaseType)){
                        //数据库为oracle时执行的操作
                    sql.append(" and tsb.到货日期<=  to_date('").append(op_.get结束到货日期()).append(" 23:59:59','yyyy-mm-dd hh24:mi:ss')");
                }
            }
            if(!StringUtil.isEmpty(op_.get起始安装日期())){
                if("SQLSERVER".equals(dataBaseType)){
                    //数据库为sqlserver时执行的操作
                    sql.append(" and tmx.调出时间 >= '"+op_.get起始安装日期()+"'");
                }else if("ORACLE".equals(dataBaseType)){
                        //数据库为oracle时执行的操作
                    sql.append(" and tmx.调出时间 >=  to_date('").append(op_.get起始安装日期()).append(" 23:59:59','yyyy-mm-dd hh24:mi:ss')");
                }
            }
            if(!StringUtil.isEmpty(op_.get结束安装日期())){
                if("SQLSERVER".equals(dataBaseType)){
                    //数据库为sqlserver时执行的操作
                    sql.append(" and tmx.调出时间 <= '"+op_.get结束安装日期()+"'");
                }else if("ORACLE".equals(dataBaseType)){
                        //数据库为oracle时执行的操作
                    sql.append(" and tmx.调出时间<=  to_date('").append(op_.get结束安装日期()).append(" 23:59:59','yyyy-mm-dd hh24:mi:ss')");
                }
            }
            if (!StringUtil.isEmpty(op_.get安装位置())) {
            	sql.append(" and tsb.安装地点 like '%"+op_.get安装位置()+"%'");
			}
            if(!StringUtil.isEmpty(op_.get使用人())){
                sql.append(" and tmx.使用人 = '"+op_.get使用人()+"'");
            }
            if(!StringUtil.isEmpty(op_.get使用人id())){
                sql.append(" and tmx.使用人id = '"+op_.get使用人id()+"'");
            }
            
    	}
    	
    	sql.append(" order by tsb.设备编码  desc");
    	
    	return sql.toString();
    }
    
    
    /**
     * 根据查询条件获取设备位置信息记录集
     * @param opt_
     * @return  List<Eq设备位置> 位置信息记录集, Null 失败
     */
    public List<Ma安装位置> getEqLocations(LocCdt opt_){
        try {
			StringBuffer sql=new StringBuffer();
			sql.append("from Ma安装位置 a where 1=1 ");
			if(opt_!=null){
				if(!StringUtil.isEmpty(opt_.get设备编码())){
					sql.append(" and a.设备编码 ='").append(opt_.get设备编码()).append("'");
				}
				if(!StringUtil.isEmpty(opt_.get使用单位())){
					sql.append(" and a.使用单位 ='").append(opt_.get使用单位()).append("'");
				}
				if(!StringUtil.isEmpty(opt_.get设备名称())){
					sql.append(" and (a.设备名称 like '%").append(opt_.get设备名称()).append("%' or a.设备分类 like '%").append(opt_.get设备名称()).append("%' ) ");
				}
			}
			return service.findObjsHQL(sql.toString());
		} catch (Exception e) {
			log.error(e.getMessage(),e);
			return null;
		}
    }

    /**
     * 根据设备Id获取设备当前位置信息
     * @param id_
     * @return Eq设备位置 位置信息, Null 失败
     */
    public Ma安装位置 getLocation(String id_){
        try {
			List<Ma安装位置> list=service.findObjsHQL("from Ma安装位置 a where a.设备id='"+id_+"' and a.状态='在管'");
			return list==null||list.isEmpty()?null:list.get(0);
		} catch (Exception e) {
			log.error(e.getMessage(),e);
			return null;
		}
    }

    /**
     * 创建设备位置信息
     * @param loc
     * @return String id_ 位置信息id, Null 失败
     */
    public String createLocation(Ma安装位置 loc){
        try {
			service.addObj(loc);
        	return loc.getOid();
		} catch (Exception e) {
			log.error(e.getMessage(),e);
			return null;
		}
    }

    /**
     * 修改设备位置信息
     * @param loc
     * @return true 成功, false 失败
     */
    public Boolean updateLocation(Ma安装位置 loc){
    	try {
    		service.modifyObj(loc);
    		return true;
    	} catch (Exception e) {
    		log.error(e.getMessage(), e);
    		return false;
    	}
    }

    /**
     * 删除设备位置信息
     * @param id_
     * @return true 成功, false 失败
     */
    public Boolean deleteLocation(String id_){
    	try {
    		service.removeObj(Ma安装位置.class,id_);
    		return true;
    	} catch (Exception e) {
    		log.error(e.getMessage(), e);
    		return false;
    	}
    }

    /**
     * 获取设备总台账信息
     * @param op_
     * @return List< EqLedger> 设备总台账数据集, NULL 失败
     */
    public List<MaLedger> getEqLedgers(MaLedgerCdt op_){
        try {
			return service.findSQLAlias(buildGetEqLedgersByPage(op_),MaLedger.class);
		} catch (Exception e) {
    		log.error(e.getMessage(), e);
    		return null;
		}
    }

    public String pageInitGetEqLedgers(MaLedgerCdt op_, String roll_){
    	try {
			return pageFind(roll_,buildGetEqLedgersByPage(op_),new HashMap(),4,MaLedger.class);
		} catch (Exception e) {
    		log.error(e.getMessage(), e);
    		return null;
		}
    }
    
    private String buildGetEqLedgersByPage(MaLedgerCdt op_){
    	StringBuffer sql=new StringBuffer();
    	String dataBaseType = DatabaseUtil.getDataBaseType(dataSource);
    	if("SQLSERVER".equals(dataBaseType)){
    	        //数据库为sqlserver时执行的操作
    	    sql.append("select 设备型号,convert(varchar(32),max(设备型号ID)) as 设备型号id,分类名称 设备分类,convert(varchar(10),sum(1)) 设备总数量,");
            sql.append("convert(varchar(10),sum(case when 设备状态='报废' then 1 else 0 end)) 报废设备数,");
            sql.append("convert(varchar(10),sum(case when 设备状态='在用' then 1 else 0 end)) 使用设备数,");
            sql.append("convert(varchar(10),sum(case when 设备状态='库存' then 1 else 0 end)) 库存设备数,");
            sql.append("convert(varchar(10),sum(case when 设备状态='维修' then 1 else 0 end)) 维修设备数 ");
            sql.append(" from MA_设备 where 1=1 ");
    	}else if("ORACLE".equals(dataBaseType)){
    	        //数据库为oracle时执行的操作
    	    sql.append("select 设备型号,to_char(max(设备型号ID)) as \"设备型号id\",分类名称 设备分类,to_char(sum(1)) 设备总数量,");
            sql.append("to_char(sum(case when 设备状态='报废' then 1 else 0 end)) 报废设备数,");
            sql.append("to_char(sum(case when 设备状态='在用' then 1 else 0 end)) 使用设备数,");
            sql.append("to_char(sum(case when 设备状态='库存' then 1 else 0 end)) 库存设备数,");
            sql.append("to_char(sum(case when 设备状态='维修' then 1 else 0 end)) 维修设备数 ");
            sql.append(" from MA_设备 where 1=1 ");
    	}
    	if(op_!=null){
    		if(!StringUtil.isEmpty(op_.get类型名称())){
    			sql.append(" and 设备类型 = '").append(op_.get类型名称()).append("' ");
    		}
    		if(!StringUtil.isEmpty(op_.get设备分类())){
    			sql.append(" and 设备型号 like '%").append(op_.get设备分类()).append("%' ");
    		}
    		if(!StringUtil.isEmpty(op_.get设备型号())){
    			sql.append(" and 设备型号 like '%").append(op_.get设备型号()).append("%' ");
    		}
    	}
    	sql.append(" group by 设备型号,分类名称 ");
        return sql.toString();
    }

    /**
     * 创建设备回收单
     * @param er_
     * @return String 回收单ID, NULL 失败
     */
    public String createEqRecover(Ma回收单 er_){
        
        return null;
    }

    /**
     * 根据回收单ID获取设备回收单
     * @param id_
     * @return EqRecover回收单对象, NULL 失败
     */
    public Ma回收单 getEqRecover(String id_){
        return null;
    }

    /**
     * 根据查询条件获取设备回收单集
     * @param op_
     * @return List<EqRecover> 回收单对象集, NULL 失败
     */
    public List<Ma回收单> getEqRecovers(MaRecoverCdt op_){
        return null;
    }

    /**
     * 根据查询条件获取设备回收单集
     * @param op_
     * @return List<EqRecover> 回收单对象集, NULL 失败
     */
    public String pageInitGetEqRecovers(MaRecoverCdt cdt, String roll){
        return null;
    }

    /**
     * 修改设备回收单
     * @param er_
     * @return True 成功, False 失败
     */
    public Boolean updateEqRecover(Ma回收单 er_){
        return null;
    }

    /**
     * 删除设备回收单
     * @param id_
     * @return True 成功, False 失败
     */
    public Boolean deleteEqRecover(String id_){
        return null;
    }

    /**
     * 创建设备移交单
     * @param et_
     * @return String 回收单ID, NULL 失败
     */
    public String createEqTransfer(Ma移交单 et_){
        return null;
    }

    /**
     * 根据移交ID获取设备移交信息
     * @param id_
     * @return EqTransfer 回收单, NULL 失败
     */
    public Ma移交单 getEqTransfer(String id_){
        return null;
    }

    /**
     * 根据移交单查询条件获取设备移交信息集
     * @param op_
     * @return List<EqTransfer> 回收单集, NULL 失败
     */
    public List<Ma移交单> getEqTransfers(MaTransferCdt op_){
        return null;
    }

    /**
     * 分页获取设备移交信息集
     * @param op_
     * @return List<EqTransfer> 回收单集, NULL 失败
     */
    public String pageInitetEqTransfers(MaTransferCdt cdt, String roll){
        return null;
    }

    /**
     * 修改设备移交单
     * @param et_
     * @return True 成功, False 失败
     */
    public Boolean updateEqTransfer(Ma移交单 et_){
        return null;
    }

    /**
     * 根据移交单ID删除设备移交单
     * @param id_
     * @return True 成功, False 失败
     */
    public Boolean deleteEqTransfer(String id_){
        return null;
    }

    /**
     * 创建设备报废信息
     * @param es_
     * @return String 报废信息ID， NULL 失败
     */
    public String createEqScrap(Ma报废单 es_){
        try {
            return maEquipmentTrans.serviceCreateEqScrap(es_);
        } catch (Exception e) {
            log.error(e.getMessage());
            e.printStackTrace();
            throw new RuntimeException();
        }
    }

    /**
     * 获取一个设备报废信息
     * @param id_
     * @return EqScrap报废信息, NULL 失败
     */
    public Ma报废单 getEqScrap(String id_){
        try{
            List<Ma设备报废明细> list = new ArrayList<Ma设备报废明细>();
            list =  service.findObjsHQL("from Ma设备报废明细 where 单据id ='"+id_+"'");
            Ma报废单 bill = (Ma报废单) service.findObj(Ma报废单.class, id_);
            if(list!=null&&list.size()>0){
                bill.setEqBfList(list);
            }
            return bill;
        }catch(Exception e){
            log.error(e.getMessage());
            e.printStackTrace();
            return null;
        }
         
    }

    /**
     * 获取设备报废信息集
     * @param op_
     * @return List<EqScrap> 报废信息集, NULL 失败
     */
    public List<Ma报废单> getEqScraps(MascrapCdt op_){
        
        try{
            return (List<Ma报废单>) service.findObjsHQL(GetSql_EqScraps(op_));
        }catch(Exception e){
            log.error(e.getMessage());
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取设备报废信息集
     * @param op_
     * @return List<EqScrap> 报废信息集, NULL 失败
     */
    public String pageInitGetEqScraps(MascrapCdt cdt, String roll_){
        try{
            return pageFind(roll_, GetSql_EqScraps(cdt));
        }catch(Exception e){
            log.error(e.getMessage());
            e.printStackTrace();
            return null;
        }
    }
    /**
     * 报废查询条件
     * @param cdt
     * @return
     */
    public String GetSql_EqScraps(MascrapCdt cdt){
        String dataBaseType = DatabaseUtil.getDataBaseType(dataSource);
        StringBuffer buffer = new StringBuffer();
        buffer.append(" from Ma报废单  a where 1=1 ");
        if(cdt != null){
            if(!StringUtil.isEmpty(cdt.get使用单位())){
                buffer.append("and a.使用单位 like '%" + cdt.get使用单位() + "%' ");
            }
            if(!StringUtil.isEmpty( cdt.get开始报废时间())){
                if("SQLSERVER".equals(dataBaseType)){
                    //数据库为sqlserver时执行的操作
                    buffer.append("and a.报废日期  >='" + cdt.get开始报废时间() + "' ");
                }else if("ORACLE".equals(dataBaseType)){
                        //数据库为oracle时执行的操作
                    buffer.append("and a.报废日期 >= to_date('").append(cdt.get开始报废时间()).append(" 23:59:59','yyyy-mm-dd hh24:mi:ss')");
                }
            }
            if(!StringUtil.isEmpty( cdt.get结束报废时间())){
                if("SQLSERVER".equals(dataBaseType)){
                    //数据库为sqlserver时执行的操作
                    buffer.append("and a.报废日期  <='" + cdt.get结束报废时间() + "' ");
                }else if("ORACLE".equals(dataBaseType)){
                        //数据库为oracle时执行的操作
                    buffer.append("and a.报废日期  <= to_date('").append(cdt.get结束报废时间()).append(" 23:59:59','yyyy-mm-dd hh24:mi:ss')");
                }
            }
            if(!StringUtil.isEmpty(cdt.get计划状态())){
                buffer.append("and a.审批状态  like '%" + cdt.get计划状态() + "%' ");
            }
            if(!StringUtil.isEmpty(cdt.get设备名称())){
                buffer.append("and a.提交人姓名 like '%" + cdt.get设备名称() + "%' ");
            }
            if(!StringUtil.isEmpty(cdt.get设备编号())){
                buffer.append("and a.单据编号 like '%" + cdt.get设备编号() + "%' ");
            }
        }
        buffer.append(" and a.报废类型 ='设备' order by a.录入时间   desc");
        return buffer.toString();
    }

    /**
     * 修改设备报废信息
     * @param es_
     * @return True 成功, False 失败
     */
    public Boolean updateEqScrap(Ma报废单 es_){
        
        try{
           return   maEquipmentTrans.serviceUpdateEqScrap(es_);
        }catch(Exception e){
            log.error(e.getMessage());
            e.printStackTrace();
            return false;
        }
       
    }

    /**
     * 删除一个设备报废信息
     * @param id_
     * @return True 成功, False 失败
     */
    public Boolean deleteEqScrap(String id_){
        
        try{
            return maEquipmentTrans.serviceDeleteEqScrap(id_);
        }catch(Exception e){
            log.error(e.getMessage());
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 创建维修计划
     * @param eop_
     * @return String 维修计划ID, NULL 失败
     */
    public String createMaOverhaulPlan(Ma维修计划 eop_){
        try{
            return maEquipmentTrans.serviceCreateMaOverhaulPlan(eop_);
        }catch(Exception e){
            log.error(e.getMessage());
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 根据维修计划ID获取维修计划
     * @param id_
     * @return Ma维修计划 维修计划, NULL 失败
     */
    public Ma维修计划 getMaOverhaulPlan(String id_){
        try{
            Ma维修计划 maPlan=(Ma维修计划) service.findObj(Ma维修计划.class, id_);
            maPlan.setDetailList(service.findObjsHQL("from Ma维修计划明细 where 维修计划id ='"+id_+"'"));
            return maPlan;
        }catch(Exception e){
            log.error(e.getMessage());
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 根据维修计划查询条件获取维修计划
     * @param op_
     * @return List<Ma维修计划> 维修计划集, NULL 失败
     */
    public List<Ma维修计划> getMaOverhaulPlans(MaOverhaulPlanCdt op_){
        try {
			return service.findObjsHQL(GetSql_GetMaOverhaulPlans(op_));
		} catch (Exception e) {
            log.error(e.getMessage());
            e.printStackTrace();
            return null;
		}
    }

    /**
     * 分页获取维修计划
     * @param op_
     * @return List<Ma维修计划> 维修计划集, NULL 失败
     */
    public String pageInitGetMaOverhaulPlans(MaOverhaulPlanCdt cdt, String roll_){
    	 try {
 			return pageFind(roll_,GetSql_GetMaOverhaulPlans(cdt));
 		} catch (Exception e) {
             log.error(e.getMessage());
             e.printStackTrace();
             return null;
 		}
    }
    
    /**
     * 设备维修计划查询sql语句  这里 和 维修信息查询 sql语句有区别
     * 设备维修计划里面是查看的Ma维修计划表中，而维修信息查询 是查找维修计划表中
     * @param cdt
     * @return
     */
    public String GetSql_GetMaOverhaulPlans(MaOverhaulPlanCdt cdt){
        String dataBaseType = DatabaseUtil.getDataBaseType(dataSource);
        StringBuffer buffer = new StringBuffer();
        buffer.append(" from Ma维修计划  a where 1=1 ");
        if(cdt != null){
            if(!StringUtil.isEmpty(cdt.get设备编码())){
                buffer.append("and a.单据编号 like '%" + cdt.get设备编码() + "%' ");
            }
            if(!StringUtil.isEmpty(cdt.get维修单位())){
                buffer.append("and a.申请单位 like '%" + cdt.get维修单位() + "%' ");
            }
            if(!StringUtil.isEmpty( cdt.get维修开始时间())){
                if("SQLSERVER".equals(dataBaseType)){
                    //数据库为sqlserver时执行的操作
                    buffer.append("and a.申请时间  <='" + cdt.get维修开始时间() + "' ");
                }else if("ORACLE".equals(dataBaseType)){
                        //数据库为oracle时执行的操作
                    buffer.append("and a.申请时间 >= to_date('").append(cdt.get维修开始时间()).append(" 23:59:59','yyyy-mm-dd hh24:mi:ss')");
                }
                //buffer.append("and a.申请时间  >='" + cdt.get维修开始时间() + "' ");
            }
            if(!StringUtil.isEmpty( cdt.get维修结束时间())){
                if("SQLSERVER".equals(dataBaseType)){
                    //数据库为sqlserver时执行的操作
                    buffer.append("and a.申请时间  <='" + cdt.get维修结束时间() + "' ");
                }else if("ORACLE".equals(dataBaseType)){
                        //数据库为oracle时执行的操作
                    buffer.append("and a.申请时间 <=to_date('").append(cdt.get维修结束时间()).append(" 23:59:59','yyyy-mm-dd hh24:mi:ss')");
                }
            }
            if(!StringUtil.isEmpty(cdt.get维修状态())){
                buffer.append("and a.审批状态  like '%" + cdt.get维修状态() + "%' ");
            }
        }
        buffer.append(" order by a.录入时间   desc");
        return buffer.toString();
    }

    /**
     * 修改维修计划
     * @param eop_
     * @return True 成功, False 失败
     */
    public Boolean updateMaOverhaulPlan(Ma维修计划 eop_){
        try{
            return maEquipmentTrans.serviceUpdateMaOverhaulPlan(eop_);
        }catch(Exception e){
            log.error(e.getMessage());
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除维修计划
     * @param id_
     * @return True 成功, False 失败
     */
    public Boolean deleteMaOverhaulPlan(String id_){
        try{
            return maEquipmentTrans.serviceDeleteMaOverhaulPlan(id_);
        }catch(Exception e){
            log.error(e.getMessage());
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 保存维修计划审批信息
     * @return
     */
    public Boolean createMaOverhualPlanApporve(Ma物资流程审批 ea_){
        return null;
    }

    /**
     * 根据查询条件统计维修信息
     * @param op_
     * @return List<MaOverhaulCnt> 维修统计结果集, NULL 失败
     */
    public List<MaOverhaulCnt> getMaOverhaulCnt(MaOverhaulCntCdt op_){
        try {
			return service.findSQLAlias(pageInitGetMaOverhaulCnt(op_), MaOverhaulCnt.class);
		} catch (Exception e) {
            log.error(e.getMessage());
            e.printStackTrace();
            return null;
		}
    }

    /**
     * 分页统计维修信息
     * @param op_
     * @return List<MaOverhaulCnt> 维修统计结果集, NULL 失败
     */
    public String pageInitCntsGetMaOverhaulCnt(MaOverhaulCntCdt cdt, String roll_){
    	try {
			return pageFind(roll_, pageInitGetMaOverhaulCnt(cdt),new HashMap(),4,MaOverhaulCnt.class);
		} catch (Exception e) {
            log.error(e.getMessage());
            e.printStackTrace();
            return null;
		}
    }

    private String pageInitGetMaOverhaulCnt(MaOverhaulCntCdt op_){
    	StringBuffer sql=new StringBuffer();
    	String dataBaseType = DatabaseUtil.getDataBaseType(dataSource);
    	if("SQLSERVER".equals(dataBaseType)){
    	        //数据库为sqlserver时执行的操作
    	    sql.append(" select convert(varchar(32),eq.OID) as 设备id,eq.设备编码 设备编号,eq.设备名称,eq.设备型号,convert(varchar(10),isnull(fi.totalcnt,0)) as 维修次数,convert(varchar(10),isnull(fi.greatcnt,0)) as 大修次数,convert(varchar(10),isnull(fi.cnt,0)) as 消耗配件,convert(varchar(32),isnull(fi.tm,0)) as 投入费用");
            sql.append(" from MA_设备 as eq left join (   select a.维修设备ID,sum(b.cnt) as cnt,isnull(sum(b.tm),0)+isnull(SUM(a.人工费),0) as tm,COUNT(a.oid) as totalcnt,count(case when 维修类型='大修' then 1 else 0 end) as greatcnt from MA_维修计划明细 as a ");
            sql.append(" left join (select 维修计划明细ID,sum(费用) as tm,0 as cnt from MA_维修费用明细 group by 维修计划明细ID) as b on a.oid=b.维修计划明细ID  ");
            sql.append(" where 维修状态 not in('计划','待修') ");
    	}else if("ORACLE".equals(dataBaseType)){
    	        //数据库为oracle时执行的操作
    	    
    	    //group by a.维修设备ID) fi给fi付不上值
    	    sql.append(" select to_char(eq.OID) as \"设备id\",eq.设备编码 设备编号,eq.设备名称,eq.设备型号,to_char(nvl(fi.totalcnt,0)) as 维修次数,to_char(nvl(fi.greatcnt,0)) as 大修次数,to_char(nvl(fi.cnt,0)) as 消耗配件,to_char(nvl(fi.tm,0)) as 投入费用");
            sql.append(" from MA_设备  eq left join (select a.维修设备ID,sum(b.cnt) as cnt,nvl(sum(b.tm),0)+nvl(SUM(a.人工费),0) as tm,COUNT(a.oid) as totalcnt,COUNT(case when 维修类型='大修' then 1 else 0 end) as greatcnt from MA_维修计划明细 a ");
            sql.append(" left join (select 维修计划明细ID,sum(费用) as tm,0 as cnt from MA_维修费用明细 group by 维修计划明细ID) b on a.oid=b.维修计划明细ID  ");
            sql.append(" where 维修状态 not in('计划','待修') ");
    	}
    	if(null!=op_&&!StringUtil.isEmpty(op_.get维修开始时间())){
    	    if("SQLSERVER".equals(dataBaseType)){
    	        //数据库为sqlserver时执行的操作
    	        sql.append(" and 维修开始日期>='").append(op_.get维修开始时间()).append(" 00:00:00' ");
        	}else if("ORACLE".equals(dataBaseType)){
        	        //数据库为oracle时执行的操作
        	    sql.append(" and 维修开始日期>=to_date('").append(op_.get维修开始时间()).append(" 23:59:59','yyyy-mm-dd hh24:mi:ss')");
        	}
    	}
		if(null!=op_&&!StringUtil.isEmpty(op_.get维修结束时间())){
		    if("SQLSERVER".equals(dataBaseType)){
		        //数据库为sqlserver时执行的操作
		        sql.append(" and 维修开始日期<='").append(op_.get维修结束时间()).append(" 23:59:59' ");
    		}else if("ORACLE".equals(dataBaseType)){
    		        //数据库为oracle时执行的操作
    		    sql.append(" and 维修开始日期<=to_date('").append(op_.get维修结束时间()).append(" 23:59:59','yyyy-mm-dd hh24:mi:ss')");
    		}
			
		}
    	sql.append("group by a.维修设备ID) fi on fi.维修设备id=eq.oid where 1=1 ");
    	if(null!=op_&&!StringUtil.isEmpty(op_.get设备型号()))
    		sql.append(" and eq.设备型号 like '%").append(op_.get设备型号()).append("%' ");
    	if(null!=op_&&!StringUtil.isEmpty(op_.get设备id()))
    		sql.append(" and eq.oid='").append(op_.get设备id()).append("' ");
    	return sql.toString();
    }
    
    /**
     * 创建维修计划明细
     * @param eo_
     * @return String 维修计划明细ID, NULL 失败
     */
    public String createMaOverhaul(Ma维修计划明细 eo_){
        try {
			maEquipmentTrans.serviceCreateMaOverhaul(eo_);
        	return eo_.getOid();
		} catch (Exception e) {
			log.error(e.getMessage(),e);
			return null;
		}
    }

    /**
     * 根据维修计划明细ID获取维修计划明细
     * @param id_
     * @return Ma维修计划明细维修计划明细, NULL 失败
     */
    public Ma维修计划明细 getMaOverhaul(String id_){
        try {
        	Ma维修计划明细 eo=(Ma维修计划明细) service.findObj(Ma维修计划明细.class, id_);
        	eo.setFyList(service.findObjsHQL("from Ma维修费用明细 a where a.维修计划明细id='"+id_+"'"));
        	return eo;
		} catch (Exception e) {
			log.error(e.getMessage(),e);
			return null;
		}
    }

    /**
     * 根据维修计划明细查询条件获取维修计划明细集
     * @param eoo_
     * @return List<Ma维修计划明细> 维修计划明细集, NULL 失败
     */
    public List<Ma维修计划明细> getMaOverhauls(MaOverhaulPlanCdt eoo_){
        try {
        	Map<String, Object> para=new HashMap<String, Object>();
			return service.findObjsHQL(getMaOverhaulsSql(eoo_,para),para);
		} catch (Exception e) {
			log.error(e.getMessage(),e);
			return null;
		}
    }

    public String pageInitGetMaOverhauls(MaOverhaulPlanCdt eoo_, String roll_){
    	try {
			return pageFind(roll_, getMaOverhaulsSql1(eoo_), new HashMap(), 4, Ma维修计划明细.class);
		} catch (Exception e) {
			log.error(e.getMessage(),e);
			return null;
		}
    }

    public String getMaOverhaulsSql(MaOverhaulPlanCdt eoo_,Map<String , Object> param){
        String dataBaseType = DatabaseUtil.getDataBaseType(dataSource);
    	StringBuffer hql=new StringBuffer();
    	hql.append("from Ma维修计划明细  a where 1=1 ");
    	if(null!=eoo_){
    		if(!StringUtil.isEmpty(eoo_.get设备编码())){
    			hql.append(" and a.设备编码  like :eid");
    			param.put("eid", "%"+eoo_.get设备编码()+"%");
    		}
    		if(!StringUtil.isEmpty(eoo_.get设备型号())){
    			hql.append(" and a.设备型号 like :tid");
    			param.put("tid", eoo_.get设备型号());
    		}
    		if(!StringUtil.isEmpty(eoo_.get维修状态())){
    			hql.append(" and a.维修状态 = :status");
    			param.put("status", eoo_.get维修状态());
    			//查询维修计划
    			if("计划".equals(eoo_.get维修状态())||"待修".equals(eoo_.get维修状态())){
    				if(!StringUtil.isEmpty(eoo_.get维修类型())){
    					hql.append(" and a.计划维修类型 = :type ");
    					param.put("type", eoo_.get维修类型());
    				}
    				if(!StringUtil.isEmpty(eoo_.get维修方式())){
    					hql.append(" and a.计划维修方式 = :pattern ");
    					param.put("pattern", eoo_.get维修方式());
    				}
    				if(!StringUtil.isEmpty(eoo_.get维修开始时间())){
    				    if("SQLSERVER".equals(dataBaseType)){
    				        //数据库为sqlserver时执行的操作
    				        hql.append(" and a.计划维修时间>= :start ");
                            param.put("start", eoo_.get维修开始时间());
        				}else if("ORACLE".equals(dataBaseType)){
        				        //数据库为oracle时执行的操作
        				    hql.append(" and to_char(a.计划维修时间 ,'yyyy-mm-dd') >= :start ");
                            param.put("start", eoo_.get维修开始时间());
        				}

    				}
    				if(!StringUtil.isEmpty(eoo_.get维修结束时间())){
    					hql.append(" and a.计划维修时间 <= :end ");
    					param.put("end", eoo_.get维修结束时间());
    				}
    			}
    			//查询维修信息
    			else {
    				if(!StringUtil.isEmpty(eoo_.get维修类型())){
    					hql.append(" and a.维修类型 = :type ");
    					param.put("type", eoo_.get维修类型());
    				}
    				if(!StringUtil.isEmpty(eoo_.get维修方式())){
    					hql.append(" and a.维修方式 = :pattern ");
    					param.put("pattern", eoo_.get维修方式());
    				}
    				if(!StringUtil.isEmpty(eoo_.get维修开始时间())){
    					hql.append(" and a.维修开始日期 >= :start ");
    					param.put("start", eoo_.get维修开始时间());
    				}
    				if(!StringUtil.isEmpty(eoo_.get维修结束时间())){
    					hql.append(" and a.维修开始日期 <= :end ");
    					param.put("end", eoo_.get维修结束时间());
    				}
    			}
    		}
    	}
    	String a=hql.append(" order by a.设备编码 desc").toString();
    	return a;
    }
    public String getMaOverhaulsSql1(MaOverhaulPlanCdt eoo_){
    	StringBuffer sql=new StringBuffer();
    	String dataBaseType = DatabaseUtil.getDataBaseType(dataSource);
    	if("SQLSERVER".equals(dataBaseType)){
    	        //数据库为sqlserver时执行的操作
    	    sql.append("select convert(varchar(32),model.OID)as oid,convert(varchar(32),model.维修计划ID) as 维修计划id," +
                    "convert(varchar(32),model.维修设备ID) as 维修设备id,model.设备编码,model.设备名称,convert(varchar(32)," +
                    "model.设备分类ID) as 设备分类id,model.分类编码,model.设备分类,convert(varchar(32),model.设备型号ID) as 设备型号id" +
                    ",model.设备型号,model.维修状态,model.计划维修方式,convert(varchar(32),model.维修发起人ID) as 维修发起人id," +
                    "model.维修发起人姓名,convert(varchar(32),model.计划维修负责人ID) as 计划维修负责人id,model.计划维修负责人," +
                    "convert(varchar(32),model.计划维修单位ID) as 计划维修单位id,model.计划维修单位编码,model.计划维修单位," +
                    "model.计划维修类型,model.计划维修时间,model.维修级别,model.计划维修预算,model.故障描述," +
                    "convert(varchar(32),model.维修负责人ID) as 维修负责人id,model.维修负责人,convert(varchar(32),model.维修单位ID) as 维修单位id," +
                    "model.维修单位编码,model.维修单位,model.维修类型,model.维修方式,model.维修原因,model.人工费,model.维修开始日期," +
                    "model.维修结束日期,model.维修录入时间,convert(varchar(32),model.维修信息录入人ID) as 维修信息录入人id,model.维修录入人,model.维修备注," +
                    "model.验收时间,model.维修内容,model.存在问题,model.验收结果,convert(varchar(32),model.验收人员ID) as 验收人员id," +
                    "model.验收人员,convert(varchar(32),model.验收部门ID) as 验收部门id,model.验收部门编码,model.验收部门,model.验收录入时间," +
                    "convert(varchar(32),model.验收录入人ID) as 验收录入人id,model.验收录入人姓名,model.备注信息,model.维修金额," +
                    "model1.设备状态 as 设备状态 from MA_维修计划明细 as model left join MA_设备 as model1 on model.维修设备ID=model1.OID where 1=1 ");
    	}else if("ORACLE".equals(dataBaseType)){
    	        //数据库为oracle时执行的操作
    	    sql.append("select to_char(model.OID)as \"oid\",to_char(model.维修计划ID) as \"维修计划id\"," +
                    "to_char(model.维修设备ID) as \"维修设备id\",model.设备编码,model.设备名称,to_char(" +
                    "model.设备分类ID) as \"设备分类id\",model.分类编码,model.设备分类,to_char(model.设备型号ID) as \"设备型号id\"" +
                    ",model.设备型号,model.维修状态,model.计划维修方式,to_char(model.维修发起人ID) as \"维修发起人id\"," +
                    "model.维修发起人姓名,to_char(model.计划维修负责人ID) as \"计划维修负责人id\",model.计划维修负责人," +
                    "to_char(model.计划维修单位ID) as \"计划维修单位id\",model.计划维修单位编码,model.计划维修单位," +
                    "model.计划维修类型,model.计划维修时间,model.维修级别,model.计划维修预算,model.故障描述," +
                    "to_char(model.维修负责人ID) as \"维修负责人id\",model.维修负责人,to_char(model.维修单位ID) as \"维修单位id\"," +
                    "model.维修单位编码,model.维修单位,model.维修类型,model.维修方式,model.维修原因,model.人工费,model.维修开始日期," +
                    "model.维修结束日期,model.维修录入时间,to_char(model.维修信息录入人ID) as \"维修信息录入人id\",model.维修录入人,model.维修备注," +
                    "model.验收时间,model.维修内容,model.存在问题,model.验收结果,to_char(model.验收人员ID) as \"验收人员id\"," +
                    "model.验收人员,to_char(model.验收部门ID) as \"验收部门id\",model.验收部门编码,model.验收部门,model.验收录入时间," +
                    "to_char(model.验收录入人ID) as \"验收录入人id\",model.验收录入人姓名,model.备注信息,model.维修金额," +
                    "model1.设备状态 as 设备状态 from MA_维修计划明细  model left join MA_设备 model1 on model.维修设备ID=model1.OID where 1=1 ");
    	}

    	if(null!=eoo_){
    		if(!StringUtil.isEmpty(eoo_.get设备编码())){
    			sql.append(" and model.设备编码  like '%"+eoo_.get设备编码()+"%'");
    		}
    		if(!StringUtil.isEmpty(eoo_.get设备型号())){
    			sql.append(" and model.设备型号 like '%"+eoo_.get设备型号()+"%'");
    		}
    		if(!StringUtil.isEmpty(eoo_.get计划维修单位())){
    			sql.append(" and model.计划维修单位 = '"+eoo_.get计划维修单位()+"'");
    		}
    		if(!StringUtil.isEmpty(eoo_.get维修状态())){
    			sql.append(" and model.维修状态 ='"+eoo_.get维修状态()+"'");
    			//查询维修计划
    			if("计划".equals(eoo_.get维修状态())||"待修".equals(eoo_.get维修状态())){
    				if(!StringUtil.isEmpty(eoo_.get维修类型())){
    					sql.append(" and model.计划维修类型 ='"+eoo_.get维修类型()+"'");
    				}
    				if(!StringUtil.isEmpty(eoo_.get维修方式())){
    					sql.append(" and model.计划维修方式 ='"+eoo_.get维修方式()+"'");
    				}
    				if(!StringUtil.isEmpty(eoo_.get维修开始时间())){
    				    if("SQLSERVER".equals(dataBaseType)){
    				        //数据库为sqlserver时执行的操作
    				        sql.append(" and model.计划维修时间 >='"+eoo_.get维修开始时间()+"'");
        				}else if("ORACLE".equals(dataBaseType)){
        				        //数据库为oracle时执行的操作
        				    sql.append(" and model.计划维修时间 >=to_date('").append(eoo_.get维修开始时间()).append(" 23:59:59','yyyy-mm-dd hh24:mi:ss')");
        				}

    					
    				}
    				if(!StringUtil.isEmpty(eoo_.get维修结束时间())){
    				    if("SQLSERVER".equals(dataBaseType)){
        				        //数据库为sqlserver时执行的操作
    				        sql.append(" and model.计划维修时间 <='"+eoo_.get维修结束时间()+"'");
        				}else if("ORACLE".equals(dataBaseType)){
        				        //数据库为oracle时执行的操作
        				    sql.append(" and model.计划维修时间 <=to_date('").append(eoo_.get维修结束时间()).append(" 23:59:59','yyyy-mm-dd hh24:mi:ss')");
        				}

    					
    				}
    			}
    			//查询维修信息
    			else {
    				if(!StringUtil.isEmpty(eoo_.get维修类型())){
    					sql.append(" and model.维修类型 ='"+eoo_.get维修方式()+"'");
    				}
    				if(!StringUtil.isEmpty(eoo_.get维修方式())){
    					sql.append(" and model.维修方式 ='"+eoo_.get维修方式()+"'");
    				}
    				if(!StringUtil.isEmpty(eoo_.get维修开始时间())){
    				    if("SQLSERVER".equals(dataBaseType)){
    				        //数据库为sqlserver时执行的操作
    				        sql.append(" and model.维修开始日期 >='" +eoo_.get维修开始时间()+"'");
        				}else if("ORACLE".equals(dataBaseType)){
        				        //数据库为oracle时执行的操作
        				    sql.append(" and model.维修开始日期 >=to_date('").append(eoo_.get维修开始时间()).append(" 23:59:59','yyyy-mm-dd hh24:mi:ss')");
        				}
    				}
    				if(!StringUtil.isEmpty(eoo_.get维修结束时间())){
    				    if("SQLSERVER".equals(dataBaseType)){
    				        //数据库为sqlserver时执行的操作
    				        sql.append(" and model.维修开始日期 <='"+eoo_.get维修结束时间()+"'");
        				}else if("ORACLE".equals(dataBaseType)){
        				        //数据库为oracle时执行的操作
        				    sql.append(" and model.维修开始日期 <=to_date('").append(eoo_.get维修结束时间()).append(" 23:59:59','yyyy-mm-dd hh24:mi:ss')");
        				}
    				}
    			}
    		}
    	}
    	String a=sql.append(" order by model.设备编码 desc").toString();
    	return a;
    }
    /**
     * 根据维修计划ID获取维修计划明细集
     * @param id_
     * @return List<Ma维修计划明细> 维修计划明细集, NULL 失败
     */
    public List<Ma维修计划明细> getMaOverhaulsByOid(String id_){
        try {
			return service.findObjsHQL("from Ma维修计划明细 a where a.维修计划id='"+id_+"'");
		} catch (Exception e) {
			log.error(e.getMessage(),e);
			return null;
		}
    }

    /**
     * 修改维修计划明细
     * @param eo_
     * @return True 成功, False 失败
     */
    public Boolean updateMaOverhaul(Ma维修计划明细 eo_){
        try {
			maEquipmentTrans.serviceUpdateMaOverhaul(eo_);
        	return true;
		} catch (Exception e) {
			log.error(e.getMessage(),e);
			return false;
		}
    }

    /**
     * 根据维修计划明细ID删除维修计划明细
     * @param id_
     * @return True 成功, False 失败
     */
    public Boolean deleteMaOverhaul(String id_){
    	try {
			maEquipmentTrans.serviceDeleteMaOverhaul(id_);
        	return true;
		} catch (Exception e) {
			log.error(e.getMessage(),e);
			return false;
		}
    }

    /**
     * 获取设备运行时的实时数据。该方法调用集中告警系统服务获取指定设备的实时数据
     * @param id_
     * @return List<MaValue> 实时数据集, NULL 失败
     */
    public List<MaValue> getMaRunningInfo(String id_){
        try {
			return service.findSQLAlias(getMaRunningInfoSql(id_), MaValue.class);
		} catch (Exception e) {
			log.error(e.getMessage(),e);
			return null;
		}
    }

    /**
     * 分页获取设备运行时的实时数据。该方法调用集中告警系统服务获取指定设备的实时数据
     * @param id_
     * @return List<MaValue> 实时数据集, NULL 失败
     */
    public String pageInitGetMaRunningInfo(String id_, String roll_){
    	try {
			return pageFind(roll_,getMaRunningInfoSql(id_),new HashMap(),4, MaValue.class);
		} catch (Exception e) {
			log.error(e.getMessage(),e);
			return null;
		}
    }

    private String getMaRunningInfoSql(String id_){
    	StringBuffer sql=new StringBuffer();
    	String dataBaseType = DatabaseUtil.getDataBaseType(dataSource);
    	if("SQLSERVER".equals(dataBaseType)){
    	        //数据库为sqlserver时执行的操作
    	    sql.append("select a.参数名 as collectName,a.点值 as value,getdate() as collectTime,b.计量单位 as unit,b.计量英文名 as unitEn "); 
            sql.append("from dbo.AL_KVMapping  a join dbo.AL_MonitorParam b on a.参数ID=b.OID ");
            sql.append("left join AL_MonitorObj c on a.监控对象ID=c.OID where c.设备ID='").append(id_).append("'");
    	}else if("ORACLE".equals(dataBaseType)){
    	        //数据库为oracle时执行的操作
    	    sql.append("select a.参数名 as \"collectName\",a.点值 as \"value\",sysdate as \"collectTime\",b.计量单位 as \"unit\",b.计量英文名 as \"unitEn\" "); 
            sql.append("from AL_KVMapping  a join AL_MonitorParam b on a.参数ID=b.OID ");
            sql.append("left join AL_MonitorObj c on a.监控对象ID=c.OID where c.设备ID='").append(id_).append("'");
    	}

    	return sql.toString();
    }
    
 
    public MaEquipmentTrans getMaEquipmentTrans(){
        return maEquipmentTrans;
    }

    public void setMaEquipmentTrans(MaEquipmentTrans maEquipmentTrans){
        this.maEquipmentTrans = maEquipmentTrans;
    }


    public Ma维修计划 getMaOverhaulPlanByBindId(String bindid){
        try{
            Ma维修计划 maPlan=(Ma维修计划) service.findObjsHQL("from Ma维修计划  jh where jh.bindId='"+bindid+"'").get(0);
            if(maPlan!=null){
                maPlan.setDetailList(service.findObjsHQL("from Ma维修计划明细 where 维修计划id ='"+maPlan.getOid()+"'"));
                return maPlan;
            }else{
                return null;
            }
        }catch(Exception e){
            log.error(e.getMessage());
            e.printStackTrace();
            return null;
        }
    }

    public String createEqStandingBook(Ma设备台帐 info){
        try{
            service.addObj(info);
            return info.getOid();
        }catch(Exception e){
            log.error(e.getMessage());
            e.printStackTrace();
            return null;
        }
    }

    public Boolean deleteEqStandingBook(String oid){
        try{
            service.removeObj(Ma设备台帐.class, oid);
            return true;
        }catch(Exception e){
            log.error(e.getMessage());
            e.printStackTrace();
            return false;
        }
    }

    public Ma设备台帐 getEqStandingBook(String oid){
        try{
            return (Ma设备台帐)service.findObj(Ma设备台帐.class, oid);
        }catch(Exception e){
            log.error(e.getMessage());
            e.printStackTrace();
            return null;
        }
        
    }

    public Boolean updateEqStandingBook(Ma设备台帐 info){
        try{
            service.modifyObj(info);
            return true;
        }catch(Exception e){
            log.error(e.getMessage());
            e.printStackTrace();
            return false;
        }
    }

    public Ma维修计划明细 getMaOverhaulPlanDetailByBindId(String bindid){

        try{
            Ma维修计划明细 maPlanDetail=(Ma维修计划明细) service.findObjsHQL("from Ma维修计划明细  jh where jh.bindId='"+bindid+"'").get(0);
            if(maPlanDetail!=null){
                maPlanDetail.setFyList(service.findObjsHQL("from Ma维修费用明细 where 维修计划明细id ='"+maPlanDetail.getOid()+"'"));
                return maPlanDetail;
            }else{
                return null;
            }
        }catch(Exception e){
            log.error(e.getMessage());
            e.printStackTrace();
            return null;
        }
    }

    public String pageInitGetEqpollings(MaEqpollingCdt opt, String roll){
        try{
            return pageFind(roll, getEqpollingSql(opt));
        }catch(Exception e){
            log.error(e.getMessage(),e);
            return null;
        }
    }
    
    private String getEqpollingSql(MaEqpollingCdt opt){
        String dataBaseType = DatabaseUtil.getDataBaseType(dataSource);
        StringBuffer sql = new StringBuffer();
        sql.append(" from Ma设备巡检信息 a where 1=1 ");
        if(opt != null){
            if(!StringUtil.isEmpty(opt.get设备编号())){
                sql.append(" and a.设备编码  like '%" + opt.get设备编号() + "%'");
            }
            if(!StringUtil.isEmpty(opt.get处理时间开始())){
                if("SQLSERVER".equals(dataBaseType)){
                    //数据库为sqlserver时执行的操作
                    sql.append(" and a.处理时间 >= '" + opt.get处理时间开始() + ":00'");
                }else if("ORACLE".equals(dataBaseType)){
                        //数据库为oracle时执行的操作
                    sql.append(" and a.处理时间 >= to_date('").append(opt.get处理时间开始()).append(" 23:59:59','yyyy-mm-dd hh24:mi:ss')");
                }

            }
            if(!StringUtil.isEmpty(opt.get处理时间结束())){
                if("SQLSERVER".equals(dataBaseType)){
                    //数据库为sqlserver时执行的操作
                    sql.append(" and a.处理时间 <= '" + opt.get处理时间结束() + ":00'");
                }else if("ORACLE".equals(dataBaseType)){
                        //数据库为oracle时执行的操作
                    sql.append(" and a.处理时间 <=to_date('").append(opt.get处理时间结束()).append(" 23:59:59','yyyy-mm-dd hh24:mi:ss')");
                }

            }
            if(!StringUtil.isEmpty(opt.get巡检时间开始())){
                if("SQLSERVER".equals(dataBaseType)){
                    //数据库为sqlserver时执行的操作
                    sql.append(" and a.巡检时间 >= '" + opt.get巡检时间开始() + ":00'");
                }else if("ORACLE".equals(dataBaseType)){
                        //数据库为oracle时执行的操作
                    sql.append(" and a.巡检时间>= to_date('").append(opt.get巡检时间开始()).append(" 23:59:59','yyyy-mm-dd hh24:mi:ss')");
                }

            }
            if(!StringUtil.isEmpty(opt.get巡检时间结束())){
                if("SQLSERVER".equals(dataBaseType)){
                    //数据库为sqlserver时执行的操作
                    sql.append(" and a.巡检时间 <= '" + opt.get巡检时间结束() + ":00'");
                }else if("ORACLE".equals(dataBaseType)){
                        //数据库为oracle时执行的操作
                    sql.append(" and a.巡检时间 <= to_date('").append(opt.get巡检时间结束()).append(" 23:59:59','yyyy-mm-dd hh24:mi:ss')");
                }
            }
            if(!StringUtil.isEmpty(opt.get记录时间开始())){
                if("SQLSERVER".equals(dataBaseType)){
                    //数据库为sqlserver时执行的操作
                    sql.append(" and a.记录时间 >= '" + opt.get记录时间开始() + ":00'");
                }else if("ORACLE".equals(dataBaseType)){
                        //数据库为oracle时执行的操作
                    sql.append(" and a.记录时间 >= to_date('").append(opt.get记录时间开始()).append(" 23:59:59','yyyy-mm-dd hh24:mi:ss')");
                }

            }
            if(!StringUtil.isEmpty(opt.get记录时间结束())){
                if("SQLSERVER".equals(dataBaseType)){
                    //数据库为sqlserver时执行的操作
                    sql.append(" and a.记录时间 <= '" + opt.get记录时间结束() + ":00'");
                }else if("ORACLE".equals(dataBaseType)){
                        //数据库为oracle时执行的操作
                    sql.append(" and a.记录时间 <= to_date('").append(opt.get记录时间结束()).append(" 23:59:59','yyyy-mm-dd hh24:mi:ss')");
                }

            }
            if(!StringUtil.isEmpty(opt.get处理状态())){
                sql.append(" and a.处理状态 = '" + opt.get处理状态() + "'");
            }
        }
        return sql.toString();
    }

    public String createEqpolling(Ma设备巡检信息 info){
        try{
            service.addObj(info);
            return info.getOid();
        }catch(Exception e){
            log.error(e.getMessage());
            e.printStackTrace();
            return null;
        }
    }

    public Boolean deleteEqpolling(String oid){
        try{
            service.removeObj(Ma设备巡检信息.class, oid);
            return true;
        }catch(Exception e){
            log.error(e.getMessage());
            e.printStackTrace();
            return false;
        }
    }

    public Ma设备巡检信息 getEqpolling(String oid){
        try{
            return (Ma设备巡检信息)service.findObj(Ma设备巡检信息.class, oid);
        }catch(Exception e){
            log.error(e.getMessage());
            e.printStackTrace();
            return null;
        }
    }

    public Boolean updateEqpolling(Ma设备巡检信息 info){
        try{
            service.modifyObj(info);
            return true;
        }catch(Exception e){
            log.error(e.getMessage());
            e.printStackTrace();
            return false;
        }
    }

    public List<Ma设备巡检信息> getEqpollings(MaEqpollingCdt op){
        try {
            return service.findSQLAlias(getEqpollingSql(op), MaEqpollingCdt.class);
        } catch (Exception e) {
            log.error(e.getMessage());
            e.printStackTrace();
            return null;
        }
    }

    public String pageInitGetEqList(MaCdt cdt, String roll){
        try{
            return pageFind(roll, getEqListString(cdt));
        }catch(Exception e){
            log.error(e.getMessage(),e);
            return null;
        }
    }
    
    public String getEqListString(MaCdt cdt){
        StringBuffer sql=new StringBuffer("from Ma设备 e where 1=1 ");
        if(cdt!=null){
            if(StringUtil.isEmpty(cdt.get分类ID())){
                sql.append(" and e.设备分类id='"+cdt.get分类ID()+"' ");
            }
            if(StringUtil.isEmpty(cdt.get设备型号ID())){
                sql.append(" and e.设备型号id='"+cdt.get设备型号ID()+"'");
            }
            if(StringUtil.isEmpty(cdt.get设备使用状态())){
                sql.append(" and e.设备状态='"+cdt.get设备使用状态()+"'");
            }
             }
        return sql.toString();
    }
    

}
